{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Files all have 3 columns of labels (indices are hard coded).\n",
    "\n",
    "This file uses voting to reduce noise. Currently, voting by row (best out of 3 labels) is working and is the default used. Voting by sample (best out of 9 labels) has problems with incomplete data; right now it just prints out info about incomplete samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import stats\n",
    "from collections import defaultdict\n",
    "\n",
    "MAX_FILES=4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data(filename):\n",
    "    csvfile = open(filename)\n",
    "    reader = csv.reader(csvfile)\n",
    "\n",
    "    data = []\n",
    "    for i, row in enumerate(reader):\n",
    "        if i == 0:\n",
    "            headers = row\n",
    "        else:\n",
    "            data.append(row)\n",
    "    csvfile.close()\n",
    "    return headers, data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get stats\n",
    "\n",
    "Run these cells in order to:\n",
    "* get stats for ontopicness and fluency to copy/paste\n",
    "* save percents for each topic for plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## topics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# for topics\n",
    "def decode(st):\n",
    "    ints = [int(s) for s in st.split('_')]\n",
    "    # Version 2\n",
    "    ii, j1, j2 = ints[0], np.mod(ints[1], MAX_FILES), np.mod(ints[2], MAX_FILES)\n",
    "    return ii, j1, j2\n",
    "\n",
    "# p-value of two binomial distributions\n",
    "# one sided tail\n",
    "def two_samp(x1, x2, n1, n2):\n",
    "    p1 = x1/n1\n",
    "    p2 = x2/n2\n",
    "    phat = (x1 + x2) / (n1 + n2)\n",
    "    z = (p1 - p2) / np.sqrt(phat * (1-phat) * (1/n1 + 1/n2))\n",
    "    return stats.norm.sf(np.abs(z))\n",
    "\n",
    "def print_info_t(scores, counts):\n",
    "    percs = scores / counts\n",
    "    print('total counts, on topic counts, percentages:')\n",
    "    for i in range(MAX_FILES):\n",
    "        print('{},{},{}'.format(counts[i], scores[i], percs[i]))\n",
    "\n",
    "    pvalues = np.zeros((MAX_FILES, MAX_FILES))\n",
    "    for i in range(MAX_FILES):\n",
    "        for j in range(i, MAX_FILES):\n",
    "            dist_i = [1] * scores[i] + [0] * (counts[i] - scores[i])\n",
    "            dist_j = [1] * scores[j] + [0] * (counts[j] - scores[j])\n",
    "            pvalue = two_samp(scores[i], scores[j], counts[i], counts[j])\n",
    "            pvalues[i, j] = pvalue\n",
    "            pvalues[j, i] = pvalue\n",
    "    for row in pvalues:\n",
    "        print('{:.8f},{:.8f},{:.8f},{:.8f}'.format(row[0],row[1],row[2],row[3]))\n",
    "\n",
    "def get_counts_indices(data, order_index, label_indices):\n",
    "    scores = np.zeros(MAX_FILES, dtype=int)\n",
    "    counts = np.zeros(MAX_FILES, dtype=int)\n",
    "    skipped = 0\n",
    "    for rownum, row in enumerate(data):\n",
    "        order = row[order_index]\n",
    "        for label_index in label_indices:\n",
    "            label = row[label_index].lower()\n",
    "            if len(order) > 0 and len(label) > 0:\n",
    "                a_cat, b_cat = decode(order)[1:]\n",
    "                # print(label, order, a_cat, b_cat)\n",
    "                if label == 'a' or label == 'both':\n",
    "                    scores[a_cat] += 1\n",
    "                if label == 'b' or label == 'both':\n",
    "                    scores[b_cat] += 1\n",
    "                counts[a_cat] += 1\n",
    "                counts[b_cat] += 1\n",
    "                if label not in ['a', 'b', 'both', 'neither']:\n",
    "                    print('******invalid label: {}'.format(label))\n",
    "            else:\n",
    "                # print('empty label; skipping', rownum)\n",
    "                skipped += 1\n",
    "    print('skipped {}'.format(skipped))\n",
    "    print_info_t(scores, counts)\n",
    "    return scores, counts\n",
    "\n",
    "# vote by row. each row contributes to one count (and 0 or 1 score based on majority vote)\n",
    "def get_counts_vote_row(data, order_index, label_indices):\n",
    "    scores = np.zeros(MAX_FILES, dtype=int)\n",
    "    counts = np.zeros(MAX_FILES, dtype=int)\n",
    "    skipped = 0\n",
    "    for rownum, row in enumerate(data):\n",
    "        order = row[order_index]\n",
    "        if len(order) == 0:\n",
    "            skipped += 1\n",
    "        else:\n",
    "            a_cat, b_cat = decode(order)[1:]\n",
    "            row_score_a, row_score_b, row_counts = 0, 0, 0\n",
    "            for label_index in label_indices:\n",
    "                label = row[label_index].lower()\n",
    "                if len(label) > 0:\n",
    "                    if label == 'a' or label == 'both':\n",
    "                        row_score_a += 1\n",
    "                    if label == 'b' or label == 'both':\n",
    "                        row_score_b += 1\n",
    "                    row_counts += 1\n",
    "                    if label not in ['a', 'b', 'both', 'neither']:\n",
    "                        print('******invalid label: {}'.format(label))\n",
    "                else:\n",
    "                    print('empty label for nonempty prompt', rownum)\n",
    "            # update big points\n",
    "            if row_counts == 3:\n",
    "                scores[a_cat] += row_score_a // 2\n",
    "                scores[b_cat] += row_score_b // 2\n",
    "                counts[a_cat] += 1\n",
    "                counts[b_cat] += 1\n",
    "            else:\n",
    "                print('incomplete row...')\n",
    "    print('skipped {}'.format(skipped))\n",
    "    print_info_t(scores, counts)\n",
    "    return scores, counts\n",
    "\n",
    "# vote by sample. each sample contributes to one count (and 0 or 1 score based on majority vote)\n",
    "# each sample should appear 9 times\n",
    "def get_counts_vote_all(data, order_index, label_indices):\n",
    "    samples = defaultdict(list) # key = (sample string, category), value = votes (list of 9)\n",
    "    skipped = 0\n",
    "    for rownum, row in enumerate(data):\n",
    "        order = row[order_index]\n",
    "        if len(order) == 0:\n",
    "            skipped += 1\n",
    "        else:\n",
    "            a_cat, b_cat = decode(order)[1:]\n",
    "            sample_a, sample_b = row[0], row[1]\n",
    "            for label_index in label_indices:\n",
    "                label = row[label_index].lower()\n",
    "                if len(label) > 0:\n",
    "                    if label == 'a':\n",
    "                        samples[(sample_a, a_cat)].append(1)\n",
    "                        samples[(sample_b, b_cat)].append(0)\n",
    "                    elif label == 'b':\n",
    "                        samples[(sample_a, a_cat)].append(0)\n",
    "                        samples[(sample_b, b_cat)].append(1)\n",
    "                    elif label == 'both':\n",
    "                        samples[(sample_a, a_cat)].append(1)\n",
    "                        samples[(sample_b, b_cat)].append(1)\n",
    "                    elif label == 'neither':\n",
    "                        samples[(sample_a, a_cat)].append(0)\n",
    "                        samples[(sample_b, b_cat)].append(0)\n",
    "                    else:\n",
    "                        print('******invalid label: {}'.format(label))\n",
    "                else:\n",
    "                    print('empty label for nonempty prompt', rownum)\n",
    "    print('skipped {}'.format(skipped))\n",
    "    dist = np.zeros((MAX_FILES, 10), dtype=int)\n",
    "    for sample in samples:\n",
    "        cat = sample[1]\n",
    "        samp_scores = samples[sample]\n",
    "        if len(samp_scores) != 9:\n",
    "            print('something had {} votes'.format(len(samp_scores)))\n",
    "            print(sample)\n",
    "        dist[cat, np.array(samp_scores).sum()] += 1\n",
    "    print(dist)\n",
    "    scores = np.zeros(MAX_FILES, dtype=int)\n",
    "    counts = np.zeros(MAX_FILES, dtype=int)\n",
    "    #print_info_t(scores, counts)\n",
    "    return scores, counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## fluency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def print_info_f_lists(scorelist):\n",
    "    print('mean, stdev, min, max, counts:')\n",
    "    for i in range(MAX_FILES):\n",
    "        print('{},{},{},{},{}'.format(np.mean(scorelist[i]), np.std(scorelist[i]),\n",
    "                                   np.min(scorelist[i]), np.max(scorelist[i]), len(scorelist[i])))\n",
    "\n",
    "    pvalues = np.zeros((MAX_FILES, MAX_FILES))\n",
    "    for i in range(MAX_FILES):\n",
    "        for j in range(i, MAX_FILES):\n",
    "            pvalue = stats.ttest_ind(scorelist[i], scorelist[j]).pvalue\n",
    "            pvalues[i, j] = pvalue\n",
    "            pvalues[j, i] = pvalue\n",
    "    print('p-values')\n",
    "    for row in pvalues:\n",
    "        print('{:.8f},{:.8f},{:.8f},{:.8f}'.format(row[0],row[1],row[2],row[3]))\n",
    "\n",
    "def get_fluencies_indices(data, order_index, label_indices):\n",
    "    scorelist = [[], [], [], []]\n",
    "    skipped = 0\n",
    "    for r, row in enumerate(data):\n",
    "        order = row[order_index]\n",
    "        if len(order) == 0:\n",
    "            continue\n",
    "        for label_ind_pair in label_indices:\n",
    "            a_cat, b_cat = decode(order)[1:]\n",
    "            cats = decode(order)[1:]\n",
    "            for i, ind in enumerate(label_ind_pair):\n",
    "                label = row[ind]\n",
    "                if len(label) > 0:\n",
    "                    scorelist[cats[i]].append(int(label))\n",
    "                else:\n",
    "                    skipped += 1\n",
    "    print('skipped {}'.format(skipped))\n",
    "    print_info_f_lists(scorelist)\n",
    "    return scorelist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run on all files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# aggregated human labeled everything\n",
    "dirname = 'pplm_labeled_csvs/'\n",
    "# comment out any of the below if you don't want to include them in \"all\"\n",
    "file_info = [\n",
    "#     'computers.csv',\n",
    "#     'legal.csv',\n",
    "#     'military.csv',\n",
    "#     'politics.csv',\n",
    "#     'religion.csv',\n",
    "#     'science.csv',\n",
    "#     'space.csv',\n",
    "     'negative.csv',\n",
    "     'positive.csv',\n",
    "#     'clickbait.csv'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "negative.csv\n",
      "skipped 718\n",
      "total counts, on topic counts, percentages:\n",
      "135,47,0.34814814814814815\n",
      "135,51,0.37777777777777777\n",
      "135,74,0.5481481481481482\n",
      "135,98,0.725925925925926\n",
      "0.50000000,0.30634075,0.00047632,0.00000000\n",
      "0.30634075,0.50000000,0.00249884,0.00000000\n",
      "0.00047632,0.00249884,0.50000000,0.00119276\n",
      "0.00000000,0.00000000,0.00119276,0.50000000\n",
      "\n",
      "positive.csv\n",
      "skipped 7\n",
      "total counts, on topic counts, percentages:\n",
      "135,5,0.037037037037037035\n",
      "135,56,0.4148148148148148\n",
      "135,38,0.2814814814814815\n",
      "135,101,0.7481481481481481\n",
      "0.50000000,0.00000000,0.00000002,0.00000000\n",
      "0.00000000,0.50000000,0.01073817,0.00000001\n",
      "0.00000002,0.01073817,0.50000000,0.00000000\n",
      "0.00000000,0.00000001,0.00000000,0.50000000\n",
      "\n",
      "all:\n",
      "total counts, on topic counts, percentages:\n",
      "270,52,0.1925925925925926\n",
      "270,107,0.3962962962962963\n",
      "270,112,0.4148148148148148\n",
      "270,199,0.737037037037037\n",
      "0.50000000,0.00000010,0.00000001,0.00000000\n",
      "0.00000010,0.50000000,0.33061336,0.00000000\n",
      "0.00000001,0.33061336,0.50000000,0.00000000\n",
      "0.00000000,0.00000000,0.00000000,0.50000000\n",
      "\n",
      "------------\n",
      "\n",
      "negative.csv\n",
      "skipped 0\n",
      "mean, stdev, min, max, counts:\n",
      "3.6666666666666665,1.070363962559315,1,5,405\n",
      "2.8444444444444446,1.2102443381502312,1,5,405\n",
      "3.7111111111111112,0.9952975856248306,1,5,405\n",
      "3.237037037037037,1.1124929678728444,1,5,405\n",
      "p-values\n",
      "1.00000000,0.00000000,0.54124461,0.00000003\n",
      "0.00000000,1.00000000,0.00000000,0.00000189\n",
      "0.54124461,0.00000000,1.00000000,0.00000000\n",
      "0.00000003,0.00000189,0.00000000,1.00000000\n",
      "\n",
      "positive.csv\n",
      "skipped 0\n",
      "mean, stdev, min, max, counts:\n",
      "3.414814814814815,1.0707227409225366,1,5,405\n",
      "2.7358024691358023,1.1339114693135512,1,5,405\n",
      "3.585185185185185,1.1378028546619214,1,5,405\n",
      "3.3333333333333335,1.0183501544346312,1,5,405\n",
      "p-values\n",
      "1.00000000,0.00000000,0.02868005,0.26804308\n",
      "0.00000000,1.00000000,0.00000000,0.00000000\n",
      "0.02868005,0.00000000,1.00000000,0.00095671\n",
      "0.26804308,0.00000000,0.00095671,1.00000000\n",
      "\n",
      "all:\n",
      "mean, stdev, min, max, counts:\n",
      "3.5407407407407407,1.0779241341381478,1,5,810\n",
      "2.7901234567901234,1.173956583027028,1,5,810\n",
      "3.6481481481481484,1.070780390518426,1,5,810\n",
      "3.285185185185185,1.0675472188488335,1,5,810\n",
      "p-values\n",
      "1.00000000,0.00000000,0.04452420,0.00000181\n",
      "0.00000000,1.00000000,0.00000000,0.00000000\n",
      "0.04452420,0.00000000,1.00000000,0.00000000\n",
      "0.00000181,0.00000000,0.00000000,1.00000000\n",
      "total counts\n",
      "810\n",
      "810\n",
      "810\n",
      "810\n"
     ]
    }
   ],
   "source": [
    "# hardcoded indices\n",
    "category_index = -1 # index of encoded seed and methods\n",
    "topic_indices = [2, 6, 10]\n",
    "fluency_indices = [(3,4), (7,8), (11,12)]\n",
    "\n",
    "all_scores = np.zeros(MAX_FILES, dtype=int)\n",
    "all_counts = np.zeros(MAX_FILES, dtype=int)\n",
    "percs_ordered = np.zeros((len(file_info), MAX_FILES)) # percents saved in same order as file names\n",
    "for i, fname in enumerate(file_info):\n",
    "    filename = dirname + fname\n",
    "    headers, data = get_data(filename)\n",
    "    print(fname)\n",
    "    scores, counts = get_counts_vote_row(data, category_index, topic_indices)\n",
    "#     scores, counts = get_counts_vote_all(data, category_index, topic_indices) # voting out of 9\n",
    "    all_scores += scores\n",
    "    all_counts += counts\n",
    "    percs_ordered[i] = 100 * scores / counts\n",
    "    print()\n",
    "print('all:')\n",
    "print_info_t(all_scores, all_counts)\n",
    "print('\\n------------\\n')\n",
    "\n",
    "# uber labeled fluencies\n",
    "all_fluencies = [[], [], [], []]\n",
    "for fname in file_info:\n",
    "    filename = dirname + fname\n",
    "    headers, data = get_data(filename)\n",
    "    print(fname)\n",
    "    new_scores = get_fluencies_indices(data, category_index, fluency_indices)\n",
    "    for i in range(len(all_fluencies)):\n",
    "        all_fluencies[i].extend(new_scores[i])\n",
    "    print()\n",
    "print('all:')\n",
    "print_info_f_lists(all_fluencies)\n",
    "print('total counts')\n",
    "for x in all_fluencies:\n",
    "    print(len(x))\n",
    "    \n",
    "all_scores_hist = all_fluencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## bar charts for ontopicness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run one of these two:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bag of words topics\n",
    "percs_ordered = np.array([[ 8.33333333, 57.77777778, 15.55555556, 64.44444444],\n",
    "                        [ 6.70391061, 28.88888889, 11.17318436, 40.55555556],\n",
    "                        [ 4.44444444, 18.88888889,  5.        , 27.22222222],\n",
    "                        [20.        , 71.66666667, 35.55555556, 69.44444444],\n",
    "                        [ 5.18518519, 56.94444444,  7.40740741, 54.16666667],\n",
    "                        [24.44444444, 49.44444444, 28.88888889, 61.66666667],\n",
    "                        [ 7.22222222, 46.66666667,  5.        , 45.        ]])\n",
    "\n",
    "# ours, theirs\n",
    "percs_wd = 100* np.array([[0.6, 0.4], # computers\n",
    "                          [0.4333333333, 0.6333333333],   # legal\n",
    "                          [0.35, 0.3333333333], # military\n",
    "                          [0.3333333333, 0.35], # politics\n",
    "                          [0.5166666667, 0.2833333333],# religion\n",
    "                          [0.55, 0.4], # science\n",
    "                          [0.5666666667,0.1], # space\n",
    "                         ]) \n",
    "percs_ctrl = 100* np.array([[0.75, 0.35], # computers\n",
    "                          [0.35, 0.25],   # legal\n",
    "                          [0., 0.], # military\n",
    "                          [0.35, 0.5], # politics\n",
    "                          [0.6, 1],# religion\n",
    "                          [0.75, 0.4], # science\n",
    "                          [0., 0.], # space\n",
    "                         ]) \n",
    "\n",
    "xlabels = ['Computers', 'Legal', 'Military', 'Politics', 'Religion', 'Science', 'Space']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# discriminator and BoW together\n",
    "percs_ordered = np.array([[ 3.7037037 , 41.48148148, 28.14814815, 74.81481481], # positive\n",
    "                         [34.81481481, 37.77777778, 54.81481481, 72.59259259], # negative\n",
    "                         [36.2962963 , 33.33333333, 48.88888889, 60.74074074], # clickbait\n",
    "                         [19.25925926, 39.62962963, 41.48148148, 73.7037037 ], # p+n\n",
    "                         [24.9382716 , 37.5308642 , 43.95061728, 69.38271605], # p+n+c\n",
    "                         [11.12026359, 46.89542484, 15.815486  , 51.71568627], # bag of words\n",
    "                        ])\n",
    "xlabels = ['Positive', 'Negative', 'Clickbait', 'All sentiments', \n",
    "           'All discriminators', 'All bag of words']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then run this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "########## change params here to make chart look nicer\n",
    "bar_width = 0.19 # width of bar itself\n",
    "padded_width = 0.2 # width of bar + spacing\n",
    "method_labels = ['baseline (B)', 'gradient (BC)', 'baseline+reranking (BR)', 'gradient+reranking (BCR)']\n",
    "basecolor, gradcolor = (0.4, 0.4, 1.0), (1.0, 0.4, 0.4) # color represents gradient or no gradient\n",
    "basehatch, rerankhatch = '', '//' # hatch represents reranking or no reranking\n",
    "plt.figure(figsize=(15, 5))\n",
    "swap_grad_rerank = True # True if you want to swap the order to [baseline, rerank, grad, both]\n",
    "##########\n",
    "\n",
    "colors = [basecolor, gradcolor, basecolor, gradcolor]\n",
    "hatches = [basehatch, basehatch, rerankhatch, rerankhatch]\n",
    "middle_xs = np.arange(len(xlabels)) - 1.5 * padded_width # location of tick bars\n",
    "values_to_plot = [0, 2, 1, 3] if swap_grad_rerank else [0, 1, 2, 3]\n",
    "\n",
    "for i in range(MAX_FILES):\n",
    "    ind = values_to_plot[i] # use i for x position, ind for getting values and labels\n",
    "    plt.bar(middle_xs + padded_width * i, percs_ordered[:, ind], width=bar_width,\n",
    "            label=method_labels[ind], color=colors[ind], hatch=hatches[ind], ec='black')\n",
    "    \n",
    "plt.bar(middle_xs + padded_width * (i+1), percs_wd[:, 1], width=bar_width,\n",
    "        label='weighted decoding', color=(0.4, 0.5, 0.4), ec='black')\n",
    "\n",
    "plt.bar(middle_xs + padded_width * (i+2), percs_ctrl[:, 1], width=bar_width,\n",
    "        label='CTRL', color=(0.4, 0.8, 0.4), ec='black')\n",
    "\n",
    "\n",
    "plt.xticks(np.arange(len(xlabels)), labels=xlabels, fontsize=14)\n",
    "plt.ylabel('Attribute relevance (%)', fontsize=14)\n",
    "#plt.legend(loc=(0.8,0.7), fontsize=16)\n",
    "plt.legend(fontsize=14)\n",
    "\n",
    "\n",
    "plt.figure(figsize=(15, 5))\n",
    "\n",
    "#plt.savefig('figures/bar_topics.pdf')\n",
    "baselinecolor, ourscolor = (0.4, 0.8, 0.4), (1.0, 1.0, 1.0)\n",
    "colors = [ourscolor, baselinecolor]\n",
    "method_labels = ['Ours (BCR)', 'WD']\n",
    "\n",
    "#plt.figure(figsize=(15, 5))\n",
    "for ii in range(MAX_FILES,MAX_FILES+2):\n",
    "    i = ii - MAX_FILES\n",
    "    plt.bar(middle_xs + padded_width * ii, percs_wd[:, i], width=bar_width,\n",
    "            label=method_labels[i], color=colors[i], ec='black')\n",
    "plt.xticks(np.arange(len(xlabels)), labels=xlabels)\n",
    "plt.ylabel('percent on topic')\n",
    "plt.legend()\n",
    "\n",
    "#plt.savefig('figures/bar_discrim.pdf')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### histograms for human labeled fluencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# histograms for human labeled fluencies\n",
    "titles = ['baseline (B)', 'gradient (BC)', 'baseline+reranking (BR)', 'gradient+reranking (BCR)']\n",
    "plt.figure(figsize=(7, 4))\n",
    "for cat in range(4):\n",
    "    plt.subplot(2, 2, cat+1)\n",
    "    plt.hist(all_scores_hist[cat], bins=0.5 + np.arange(0, 6), rwidth=1, density=True)\n",
    "    plt.axvline(np.mean(all_scores_hist[cat]), c='k', linestyle='--', label='mean')\n",
    "    plt.ylabel('fraction')\n",
    "    plt.ylim([0, 0.51]) # this is hardcoded. adjust as needed\n",
    "    #if cat < 3:\n",
    "    #    plt.xticks(range(1, 6), ['' for _ in range(5)])\n",
    "    plt.xticks(range(1, 6), [_+1 for _ in range(5)])\n",
    "    if cat > 1:\n",
    "        plt.xlabel('Fluency score')\n",
    "    plt.title(titles[cat])\n",
    "    if cat == 0:\n",
    "        plt.legend()\n",
    "plt.tight_layout()\n",
    "#plt.gcf().subplots_adjust(bottom=0.08)\n",
    "#plt.xlabel('fluency score')\n",
    "#plt.savefig('figures/fluency_sentiments.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
